package storage

import (
	"context"
	"fmt"
	"time"

	"new_sensitive/internal/model"

	"github.com/redis/go-redis/v9"
)

// RedisStorage Redis存储实现
type RedisStorage struct {
	client *redis.Client
	ctx    context.Context
}

// NewRedisStorage 创建Redis存储实例
func NewRedisStorage(host string, port int, password string, db int) (*RedisStorage, error) {
	// 创建Redis客户端
	client := redis.NewClient(&redis.Options{
		Addr:     fmt.Sprintf("%s:%d", host, port),
		Password: password,
		DB:       db,
	})

	// 创建上下文
	ctx := context.Background()

	// 测试连接
	if err := client.Ping(ctx).Err(); err != nil {
		return nil, fmt.Errorf("连接Redis失败: %v", err)
	}

	return &RedisStorage{
		client: client,
		ctx:    ctx,
	}, nil
}

// CacheSensitiveWords 缓存敏感词列表
func (s *RedisStorage) CacheSensitiveWords(words []model.SensitiveWord) error {
    const key = "sensitive_words"

    // 使用管道批量添加到集合
    pipe := s.client.Pipeline()
    pipe.Del(s.ctx, key) // 先清除旧数据

    // 将敏感词添加到集合
    for _, word := range words {
        pipe.SAdd(s.ctx, key, word.BadWord)
    }

    // 设置过期时间为24小时
    pipe.Expire(s.ctx, key, 24*time.Hour)

    // 执行管道命令
    if _, err := pipe.Exec(s.ctx); err != nil {
        return fmt.Errorf("缓存敏感词失败: %v", err)
    }

    return nil
}

// GetCachedSensitiveWords 获取缓存的敏感词列表
func (s *RedisStorage) GetCachedSensitiveWords() ([]model.SensitiveWord, error) {
    const key = "sensitive_words"

    // 获取集合中的所有成员
    members, err := s.client.SMembers(s.ctx, key).Result()
    if err == redis.Nil {
        return nil, nil // 缓存不存在
    }
    if err != nil {
        return nil, fmt.Errorf("获取缓存失败: %v", err)
    }

    // 如果没有数据，返回空切片
    if len(members) == 0 {
        return nil, nil
    }

    // 转换为敏感词列表
    words := make([]model.SensitiveWord, 0, len(members))
    for _, word := range members {
        words = append(words, model.SensitiveWord{
            BadWord: word,
        })
    }

    return words, nil
}

// Close 关闭Redis连接
func (s *RedisStorage) Close() error {
	return s.client.Close()
}
